Please address the comments from this code review:

## Overall Comments
- In `upsert_engine_cooldowns`, the `CASE WHEN %s > 0` currently uses the `failures` value (`(e, f, f, max(0.0, r))`), so `next_probe_at` is controlled by failures rather than `remaining_seconds`; this should likely test `remaining_seconds` instead so an engine with nonzero failures but zero remaining does not get an unnecessary future probe time.
- The cooldown freshness/remaining logic mixes DB timestamps with `_naive_utc_now()`; since `engine_cooldowns.next_probe_at`/`updated_at` are `TIMESTAMP` without time zone and `NOW()` uses the DB server clock, it would be safer either to store these as `timestamptz` or to be explicit about assuming the DB runs in UTC to avoid subtle drift between API and DB clocks.

## Individual Comments

### Comment 1
<location path="common/database.py" line_range="684-693" />
<code_context>
+def upsert_engine_cooldowns(
</code_context>
<issue_to_address>
**issue (bug_risk):** Cooldown persistence uses `failures` instead of `remaining` to gate `next_probe_at`, which can keep already-expired cooldowns alive.

The `executemany` call currently passes `(e, f, f, max(0.0, r))`, so the `CASE WHEN %s > 0` is checking `failures` instead of `remaining_seconds`. For engines with `failures > 0` but `remaining_seconds <= 0`, this still sets `next_probe_at` to `NOW()`, keeping them incorrectly benched.

If the goal is for `next_probe_at` to be NULL whenever `remaining_seconds <= 0`, and only set in the future when `remaining_seconds > 0`, the CASE should use `remaining_seconds`, e.g.:

```python
a = [(e, f, max(0.0, r), max(0.0, r)) for (e, f, r) in states]
cursor.executemany(
    "INSERT INTO engine_cooldowns (engine, failures, next_probe_at, updated_at) "
    "VALUES (%s, %s, "
    "        CASE WHEN %s > 0 THEN NOW() + make_interval(secs => %s) END, "
    "        NOW()) "
    "ON CONFLICT (engine) DO UPDATE SET "
    "  failures = EXCLUDED.failures, "
    "  next_probe_at = EXCLUDED.next_probe_at, "
    "  updated_at = EXCLUDED.updated_at",
    a,
)
```

This ensures already-elapsed cooldowns are stored with `next_probe_at = NULL` and not treated as still benched.
</issue_to_address>

### Comment 2
<location path="api/static/monitor.js" line_range="114-122" />
<code_context>
             row.querySelector('.c-health').dataset.health = e.health;

+            // Cooldown: show the countdown to the next probe beside the label.
+            const cd = row.querySelector('.ecooldown');
+            if (e.cooldown_seconds_remaining != null) {
+                cd.textContent = `~${this.fmtCountdown(e.cooldown_seconds_remaining)}`;
+                const blocks = e.cooldown_failures
+                    ? `${e.cooldown_failures} consecutive block${e.cooldown_failures === 1 ? '' : 's'}; `
+                    : '';
+                cd.title = `${blocks}probing again in ~${this.fmtCountdown(e.cooldown_seconds_remaining)}`;
+            } else {
+                cd.textContent = '';
+            }
+
</code_context>
<issue_to_address>
**issue (bug_risk):** Cooldown tooltip (`title`) is never cleared when an engine stops cooling, leaving stale hover text.

In `updateEngineRow`, the `else` branch only clears `cd.textContent`, so when an engine stops cooling the previous `cd.title` remains and shows stale tooltip text. Clear the title as well:

```js
} else {
    cd.textContent = '';
    cd.title = '';
}
```
</issue_to_address>